/**
 * Web文件系统权限持久化服务
 * 用于保存和恢复Web环境下的文件句柄权限
 */

/**
 * 存储在localStorage中的权限条目
 */
interface StoredPermissionEntry {
    id: string;
    name: string;
    lastAccessed: number;
    isDirectory: boolean;
}

/**
 * Web文件系统权限持久化管理器
 * 管理文件句柄的序列化、存储和恢复
 */
export class WebPersistenceManager {
    private static readonly STORAGE_KEY = 'web_fs_permissions';
    private static readonly MAX_ENTRIES = 10; // 最多存储的文件夹句柄数量

    /**
     * 保存文件句柄到持久存储
     * @param handle 文件句柄
     */
    static async savePermission(handle: any): Promise<void> {
        if (!handle || !handle.name) return;
        
        try {
            // 验证句柄是否可用且应用有权限
            const permission = await this.verifyPermission(handle);
            if (!permission) {
                console.warn('无法保存没有权限的文件句柄');
                return;
            }
            
            // 获取现有存储的权限
            const storedPermissions = this.getStoredPermissions();
            
            // 创建新的权限条目
            const entry: StoredPermissionEntry = {
                id: crypto.randomUUID(),
                name: handle.name,
                lastAccessed: Date.now(),
                isDirectory: handle.kind === 'directory'
            };
            
            // 检查是否已存在相同名称的条目
            const existingIndex = storedPermissions.findIndex(p => p.name === handle.name);
            if (existingIndex >= 0) {
                // 更新现有条目
                storedPermissions[existingIndex] = entry;
            } else {
                // 添加新条目
                storedPermissions.push(entry);
            }
            
            // 确保不超过最大条目数
            if (storedPermissions.length > this.MAX_ENTRIES) {
                // 按上次访问时间排序并移除最旧的
                storedPermissions.sort((a, b) => b.lastAccessed - a.lastAccessed);
                storedPermissions.splice(this.MAX_ENTRIES);
            }
            
            // 存储到localStorage
            this.saveStoredPermissions(storedPermissions);
            
            // 存储句柄到IndexedDB (需要额外实现)
            this.storeHandleInIndexedDB(entry.id, handle);
            
            console.log(`保存文件句柄权限: ${handle.name}`);
        } catch (error) {
            console.error('保存文件权限失败:', error);
        }
    }
    
    /**
     * 获取最近使用的文件夹句柄
     * @returns 最近使用的文件夹名称列表
     */
    static getRecentFolders(): StoredPermissionEntry[] {
        const permissions = this.getStoredPermissions();
        return permissions
            .filter(p => p.isDirectory)
            .sort((a, b) => b.lastAccessed - a.lastAccessed);
    }
    
    /**
     * 获取存储的权限列表
     */
    private static getStoredPermissions(): StoredPermissionEntry[] {
        try {
            const stored = localStorage.getItem(this.STORAGE_KEY);
            if (!stored) return [];
            return JSON.parse(stored);
        } catch (error) {
            console.error('解析存储的权限失败:', error);
            return [];
        }
    }
    
    /**
     * 保存权限列表
     */
    private static saveStoredPermissions(permissions: StoredPermissionEntry[]): void {
        try {
            localStorage.setItem(this.STORAGE_KEY, JSON.stringify(permissions));
        } catch (error) {
            console.error('保存权限失败:', error);
        }
    }
    
    /**
     * 验证文件句柄权限
     */
    private static async verifyPermission(handle: any): Promise<boolean> {
        try {
            if (!handle || typeof handle.queryPermission !== 'function') {
                return false;
            }
            
            // 检查当前权限
            const permission = await handle.queryPermission({ mode: 'readwrite' });
            
            if (permission === 'granted') {
                return true;
            }
            
            // 尝试请求权限
            if (permission === 'prompt') {
                const newPermission = await handle.requestPermission({ mode: 'readwrite' });
                return newPermission === 'granted';
            }
            
            return false;
        } catch (error) {
            console.error('验证文件权限失败:', error);
            return false;
        }
    }
    
    /**
     * 存储句柄到IndexedDB (简化实现)
     * 注意：完整实现需要使用IndexedDB API
     */
    private static storeHandleInIndexedDB(id: string, handle: any): void {
        // 这里仅为示例，实际实现需要使用IndexedDB API
        // 由于IndexedDB实现需要更多代码，这里简化为日志
        console.log(`存储文件句柄到IndexedDB: ${id}`);
        
        // IndexedDB实现大致如下:
        // 1. 打开数据库
        // 2. 创建/使用对象仓库
        // 3. 将句柄存储在id键下
    }
}

/**
 * Web文件系统导出API
 */
export default {
    /**
     * 保存文件句柄权限
     */
    savePermission: WebPersistenceManager.savePermission.bind(WebPersistenceManager),
    
    /**
     * 获取最近使用的文件夹
     */
    getRecentFolders: WebPersistenceManager.getRecentFolders.bind(WebPersistenceManager)
}; 